home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1999 June: Reference Library / Dev.CD Jun 99 RL Disk 1.toast / What's New / Development Kits / Mac_OS_USB_DDK_v1.2 / Examples / MouseModule / HIDEmulation.c next >
Encoding:
C/C++ Source or Header  |  1999-04-15  |  6.9 KB  |  232 lines  |  [TEXT/MPS ]
  1. /*
  2.     File:        HIDEmulation.c
  3.  
  4.     Contains:    HID Emulation glue code between the ADB SHIM and the USB Mouse HID Module
  5.  
  6.     Version:    xxx put version here xxx
  7.  
  8.     Copyright:    © 1998-1999 by Apple Computer, Inc., all rights reserved.
  9.  
  10. */
  11.  
  12. #include <Types.h>
  13. #include <Devices.h>
  14. #include <DriverServices.h>
  15. #include <CursorDevices.h>
  16. #include <USB.h>
  17.  
  18.  
  19. #include "MouseModule.h"
  20.  
  21. extern    usbMousePBStruct myMousePB;
  22.  
  23. void USBMouseIn(UInt32 refcon, void * theData)
  24. {
  25. #pragma unused (refcon)
  26.  
  27. USBHIDDataPtr    pMouseData;
  28. static UInt16     oldbuttons = 0;
  29. UInt16     changedbuttons = 0;
  30.  
  31. //    DebugStr("\pIn USBMouseIn");
  32.     pMouseData = (USBHIDDataPtr)theData;
  33.     
  34.     if (myMousePB.pCursorDeviceInfo)        // don't call cursor device manager functions without a good cursor device
  35.     {
  36.         // Tell the Cursor Device Manager that we moved
  37.         if ((pMouseData->mouse.XDelta != 0) || (pMouseData->mouse.YDelta !=0))
  38.         {
  39.             CursorDeviceMove(myMousePB.pCursorDeviceInfo, pMouseData->mouse.XDelta, pMouseData->mouse.YDelta);
  40.         }
  41.         
  42.         // Update with the state of the buttons.
  43.         pMouseData->mouse.buttons &= 0x07;
  44.         changedbuttons = oldbuttons ^ pMouseData->mouse.buttons;
  45.         if (changedbuttons)
  46.         {
  47.             CursorDeviceButtons(myMousePB.pCursorDeviceInfo, (short)pMouseData->mouse.buttons);
  48.         }
  49.         oldbuttons = pMouseData->mouse.buttons;
  50.     }
  51. }
  52.  
  53. OSStatus USBHIDInstallInterrupt(HIDInterruptProcPtr HIDInterruptFunction, UInt32 refcon)
  54. {
  55.     USBExpertStatus(myMousePB.interfaceRef, kMouseModuleName": Set interrupt pointer", (UInt32)HIDInterruptFunction);
  56.     myMousePB.interruptRefcon = refcon;            
  57.     
  58.     if (HIDInterruptFunction == USBMouseIn)                // if someone is re-installing the USBMouseIn routine then this is
  59.     {                                                    // an indication that someone earlier requested the interrupt
  60.         myMousePB.pSHIMInterruptRoutine = nil;            // pointer, saved it, and restored it.  When the USBMouseIn
  61.         USBHIDControlDevice(kHIDEnableDemoMode, 0);        // routine is to be used, we've got to re-enable demo mode,
  62.                                                         // otherwise there won't be a cursor device manager entry for us...
  63.     }
  64.     else
  65.     {
  66.         USBHIDControlDevice(kHIDDisableDemoMode, 0);    // disable demo mode
  67.         myMousePB.pSHIMInterruptRoutine = HIDInterruptFunction;
  68.     }
  69.     return noErr;
  70. }
  71.  
  72. OSStatus USBHIDInstallNotification(HIDNotificationProcPtr HIDNotification, UInt32 refcon)
  73. {
  74.     USBExpertStatus(myMousePB.interfaceRef, kMouseModuleName": Set notification proc ptr", (UInt32)HIDNotification);
  75.     myMousePB.notificationRefcon = refcon;            
  76.     
  77.     myMousePB.pNotificationRoutine = HIDNotification;
  78.     return noErr;
  79. }
  80.  
  81. OSStatus USBHIDPollDevice(void)
  82. {
  83.     return kUSBInternalErr;
  84. }
  85.  
  86. OSStatus USBHIDControlDevice(UInt32 theControlSelector, void * theControlData)
  87. {
  88. #pragma unused (theControlData)
  89.  
  90.     switch (theControlSelector)
  91.     {
  92.         case kHIDRemoveInterruptHandler:
  93.             USBExpertStatus(myMousePB.interfaceRef, kMouseModuleName": Removing interrupt handler!!!", myMousePB.interfaceRef);
  94.             myMousePB.interruptRefcon = nil;
  95.             myMousePB.pSavedInterruptRoutine = nil;
  96.             myMousePB.pSHIMInterruptRoutine = nil;
  97.             if (myMousePB.pCursorDeviceInfo != 0)
  98.             {
  99.                 CursorDeviceDisposeDevice(myMousePB.pCursorDeviceInfo);
  100.                 myMousePB.pCursorDeviceInfo = 0;
  101.             }
  102.             break;
  103.             
  104.         case kHIDRemoveNotification:
  105.             USBExpertStatus(myMousePB.interfaceRef, kMouseModuleName": Removing notification!!!", myMousePB.interfaceRef);
  106.             myMousePB.notificationRefcon = nil;
  107.             myMousePB.pNotificationRoutine = NotifyRegisteredHIDUser;
  108.             break;
  109.             
  110.         case kHIDEnableDemoMode:
  111.             USBExpertStatus(myMousePB.interfaceRef, kMouseModuleName": Demo Mode Enabled", myMousePB.interfaceRef);
  112.             
  113.             if (myMousePB.pCursorDeviceInfo == 0)
  114.             {
  115.                 myMousePB.pCursorDeviceInfo = &myMousePB.cursorDeviceInfo;
  116.                 CursorDeviceNewDevice(&myMousePB.pCursorDeviceInfo);
  117.                 
  118.                 CursorDeviceSetAcceleration(myMousePB.pCursorDeviceInfo, (Fixed)(1<<16));
  119.                 
  120.                 CursorDeviceSetButtons(myMousePB.pCursorDeviceInfo, 3);            // should actually be set by reading
  121.                                                                                 // the HID descriptor, but lacking
  122.                                                                                 // a parser, we'll just force it
  123.                                                                                 // this way.
  124.                 CursorDeviceButtonOp(myMousePB.pCursorDeviceInfo, 0, kButtonSingleClick, 0L);
  125.                 CursorDeviceButtonOp(myMousePB.pCursorDeviceInfo, 1, kButtonSingleClick, 0L);
  126.                 CursorDeviceButtonOp(myMousePB.pCursorDeviceInfo, 2, kButtonSingleClick, 0L);
  127.                 CursorDeviceUnitsPerInch(myMousePB.pCursorDeviceInfo, (Fixed)(myMousePB.unitsPerInch));
  128.             
  129.                 myMousePB.pSavedInterruptRoutine = myMousePB.pSHIMInterruptRoutine;
  130.                 myMousePB.pSHIMInterruptRoutine = USBMouseIn;
  131.             }
  132.             break;
  133.  
  134.         case kHIDDisableDemoMode:
  135.             USBExpertStatus(myMousePB.interfaceRef, kMouseModuleName": Demo Mode Disabled", myMousePB.interfaceRef);
  136.             if (myMousePB.pCursorDeviceInfo != 0)
  137.             {
  138.                 CursorDeviceDisposeDevice(myMousePB.pCursorDeviceInfo);
  139.                 myMousePB.pCursorDeviceInfo = 0;
  140.             }
  141.             myMousePB.pSHIMInterruptRoutine = myMousePB.pSavedInterruptRoutine;
  142.             break;
  143.  
  144.         default:
  145.             return paramErr;
  146.     }
  147.     return noErr;
  148. }
  149.  
  150.  
  151.  
  152. OSStatus USBHIDGetDeviceInfo(UInt32 theInfoSelector, void * theInfo)
  153. {
  154. HIDInterruptProcPtr * pHIDIntProcPtr;
  155. UInt32 * pUnits;
  156. UInt32 * pInterruptRefcon;
  157.  
  158.     switch (theInfoSelector)
  159.     {
  160.         case kHIDGetDeviceUnitsPerInch:
  161.             pUnits = (UInt32*)theInfo;
  162.             *pUnits = (UInt32)(myMousePB.unitsPerInch);
  163.             break;
  164.             
  165.         case kHIDGetInterruptHandler:
  166.             USBExpertStatus(myMousePB.interfaceRef, kMouseModuleName": Get interrupt pointer", (UInt32)(myMousePB.pSHIMInterruptRoutine));
  167.             pHIDIntProcPtr = (HIDInterruptProcPtr *)theInfo;     
  168.             *pHIDIntProcPtr = myMousePB.pSHIMInterruptRoutine;
  169.             break;
  170.  
  171.         case kHIDGetInterruptRefcon:
  172.             pInterruptRefcon = (UInt32 *)theInfo;
  173.             *pInterruptRefcon = myMousePB.interruptRefcon;
  174.             break;
  175.         
  176.         default:
  177.             return paramErr;
  178.     }
  179.     return noErr;
  180. }
  181.  
  182. OSStatus USBHIDEnterPolledMode(void)
  183. {
  184.     return unimpErr;
  185. }
  186.  
  187. OSStatus USBHIDExitPolledMode(void)
  188. {
  189.     return unimpErr;
  190. }
  191.  
  192. void NotifyRegisteredHIDUser(UInt32 refcon, UInt32 reportSize, void * theReport, USBReference theInterfaceRef)
  193. //void NotifyRegisteredHIDUser(UInt32 devicetype, UInt8 hidReport[])
  194. {
  195. #pragma unused (refcon)
  196. #pragma unused (reportSize)
  197. #pragma unused (theInterfaceRef)
  198.  
  199. USBHIDData        theMouseData;
  200. SInt8            myXDelta, myYDelta;
  201. char *             hidReport;
  202.  
  203.     hidReport = (char *)theReport;
  204.     theMouseData.mouse.buttons = (UInt16)hidReport[0];
  205.     
  206.     myXDelta = (SInt8)hidReport[1];
  207.     myYDelta = (SInt8)hidReport[2];  
  208.     
  209.     theMouseData.mouse.XDelta = (SInt16)myXDelta;
  210.     theMouseData.mouse.YDelta = (SInt16)myYDelta;
  211.     if (myMousePB.pSHIMInterruptRoutine)
  212.     {
  213.         (*myMousePB.pSHIMInterruptRoutine)(myMousePB.interruptRefcon, (void *)&theMouseData);
  214.     }
  215. }
  216.  
  217. USBHIDRev2DispatchTable TheHIDModuleDispatchTable =
  218. {
  219.     (UInt32)kHIDCurrentDispatchVersion,
  220.     (USBHIDInstallInterruptProcPtr)USBHIDInstallInterrupt,
  221.     (USBHIDPollDeviceProcPtr)USBHIDPollDevice,
  222.     (USBHIDControlDeviceProcPtr)USBHIDControlDevice,
  223.     (USBHIDGetDeviceInfoProcPtr)USBHIDGetDeviceInfo,
  224.     (USBHIDEnterPolledModeProcPtr)USBHIDEnterPolledMode,
  225.     (USBHIDExitPolledModeProcPtr)USBHIDExitPolledMode,
  226.     (USBHIDInstallNotificationProcPtr)USBHIDInstallNotification
  227. };
  228.  
  229. CursorDevicePtr gUSBMouse;
  230. CursorDevice    ourDevice;
  231.  
  232.